﻿using System;
using System.ComponentModel;
using System.IO;
using System.Runtime.Serialization;

namespace HalconDotNet
{
	/// <summary>Represents an instance of an XLD object-(array).</summary>
	// Token: 0x02000072 RID: 114
	[Serializable]
	public class HXLD : HObject, ISerializable, ICloneable
	{
		/// <summary>Create an uninitialized iconic object</summary>
		// Token: 0x06001B8A RID: 7050 RVA: 0x00026126 File Offset: 0x00024326
		public HXLD() : base(HObjectBase.UNDEF, false)
		{
		}

		// Token: 0x06001B8B RID: 7051 RVA: 0x000A9F00 File Offset: 0x000A8100
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HXLD(IntPtr key) : this(key, true)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001B8C RID: 7052 RVA: 0x000A9F16 File Offset: 0x000A8116
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HXLD(IntPtr key, bool copy) : base(key, copy)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001B8D RID: 7053 RVA: 0x000A9F2C File Offset: 0x000A812C
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HXLD(HObject obj) : base(obj)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001B8E RID: 7054 RVA: 0x000A9F41 File Offset: 0x000A8141
		private void AssertObjectClass()
		{
			HalconAPI.AssertObjectClass(this.key, "xld");
		}

		/// <summary>Returns the iconic object(s) at the specified index</summary>
		// Token: 0x17000065 RID: 101
		public HXLD this[HTuple index]
		{
			get
			{
				return this.SelectObj(index);
			}
		}

		// Token: 0x06001B90 RID: 7056 RVA: 0x000A9F5C File Offset: 0x000A815C
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static int LoadNew(IntPtr proc, int parIndex, int err, out HXLD obj)
		{
			obj = new HXLD(HObjectBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		// Token: 0x06001B91 RID: 7057 RVA: 0x000A9F74 File Offset: 0x000A8174
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = this.SerializeXld();
			byte[] value = hserializedItem;
			hserializedItem.Dispose();
			info.AddValue("data", value, typeof(byte[]));
		}

		// Token: 0x06001B92 RID: 7058 RVA: 0x000A9FAC File Offset: 0x000A81AC
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HXLD(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = new HSerializedItem((byte[])info.GetValue("data", typeof(byte[])));
			this.DeserializeXld(hserializedItem);
			hserializedItem.Dispose();
		}

		/// <summary>Serialize object to binary stream in HALCON format</summary>
		// Token: 0x06001B93 RID: 7059 RVA: 0x000A9FEC File Offset: 0x000A81EC
		public new void Serialize(Stream stream)
		{
			HSerializedItem hserializedItem = this.SerializeXld();
			hserializedItem.Serialize(stream);
			hserializedItem.Dispose();
		}

		/// <summary>Deserialize object from binary stream in HALCON format</summary>
		// Token: 0x06001B94 RID: 7060 RVA: 0x000AA000 File Offset: 0x000A8200
		public new static HXLD Deserialize(Stream stream)
		{
			HXLD hxld = new HXLD();
			HSerializedItem hserializedItem = HSerializedItem.Deserialize(stream);
			hxld.DeserializeXld(hserializedItem);
			hserializedItem.Dispose();
			return hxld;
		}

		// Token: 0x06001B95 RID: 7061 RVA: 0x000AA026 File Offset: 0x000A8226
		object ICloneable.Clone()
		{
			return this.Clone();
		}

		// Token: 0x06001B96 RID: 7062 RVA: 0x000AA030 File Offset: 0x000A8230
		public new HXLD Clone()
		{
			HSerializedItem hserializedItem = this.SerializeXld();
			HXLD hxld = new HXLD();
			hxld.DeserializeXld(hserializedItem);
			hserializedItem.Dispose();
			return hxld;
		}

		/// <summary>
		///   Return an XLD parallel's data (as lines).
		///   Instance represents: Input XLD parallels.
		/// </summary>
		/// <param name="row1">Row coordinates of the points on polygon P1.</param>
		/// <param name="col1">Column coordinates of the points on polygon P1.</param>
		/// <param name="length1">Lengths of the line segments on polygon P1.</param>
		/// <param name="phi1">Angles of the line segments on polygon P1.</param>
		/// <param name="row2">Row coordinates of the points on polygon P2.</param>
		/// <param name="col2">Column coordinates of the points on polygon P2.</param>
		/// <param name="length2">Lengths of the line segments on polygon P2.</param>
		/// <param name="phi2">Angles of the line segments on polygon P2.</param>
		// Token: 0x06001B97 RID: 7063 RVA: 0x000AA058 File Offset: 0x000A8258
		public void GetParallelsXld(out HTuple row1, out HTuple col1, out HTuple length1, out HTuple phi1, out HTuple row2, out HTuple col2, out HTuple length2, out HTuple phi2)
		{
			IntPtr proc = HalconAPI.PreCall(41);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row1);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out col1);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out length1);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out phi1);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out row2);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out col2);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out length2);
			num = HTuple.LoadNew(proc, 7, HTupleType.DOUBLE, num, out phi2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Display an XLD object.
		///   Instance represents: XLD object to display.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		// Token: 0x06001B98 RID: 7064 RVA: 0x000AA128 File Offset: 0x000A8328
		public void DispXld(HWindow windowHandle)
		{
			IntPtr proc = HalconAPI.PreCall(74);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Receive an XLD object over a socket connection.
		///   Modified instance represents: Received XLD object.
		/// </summary>
		/// <param name="socket">Socket number.</param>
		// Token: 0x06001B99 RID: 7065 RVA: 0x000AA168 File Offset: 0x000A8368
		public void ReceiveXld(HSocket socket)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(329);
			HalconAPI.Store(proc, 0, socket);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(socket);
		}

		/// <summary>
		///   Send an XLD object over a socket connection.
		///   Instance represents: XLD object to be sent.
		/// </summary>
		/// <param name="socket">Socket number.</param>
		// Token: 0x06001B9A RID: 7066 RVA: 0x000AA1BC File Offset: 0x000A83BC
		public void SendXld(HSocket socket)
		{
			IntPtr proc = HalconAPI.PreCall(330);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, socket);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(socket);
		}

		/// <summary>
		///   Calculate the difference of two object tuples.
		///   Instance represents: Object tuple 1.
		/// </summary>
		/// <param name="objectsSub">Object tuple 2.</param>
		/// <returns>Objects from Objects that are not part of ObjectsSub.</returns>
		// Token: 0x06001B9B RID: 7067 RVA: 0x000AA200 File Offset: 0x000A8400
		public HXLD ObjDiff(HXLD objectsSub)
		{
			IntPtr proc = HalconAPI.PreCall(573);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsSub);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsSub);
			return result;
		}

		/// <summary>
		///   Paint XLD objects into an image.
		///   Instance represents: XLD objects to be painted into the input image.
		/// </summary>
		/// <param name="image">Image in which the xld objects are to be painted.</param>
		/// <param name="grayval">Desired gray value of the xld object. Default: 255.0</param>
		/// <returns>Image containing the result.</returns>
		// Token: 0x06001B9C RID: 7068 RVA: 0x000AA258 File Offset: 0x000A8458
		public HImage PaintXld(HImage image, HTuple grayval)
		{
			IntPtr proc = HalconAPI.PreCall(575);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, grayval);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(grayval);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Paint XLD objects into an image.
		///   Instance represents: XLD objects to be painted into the input image.
		/// </summary>
		/// <param name="image">Image in which the xld objects are to be painted.</param>
		/// <param name="grayval">Desired gray value of the xld object. Default: 255.0</param>
		/// <returns>Image containing the result.</returns>
		// Token: 0x06001B9D RID: 7069 RVA: 0x000AA2BC File Offset: 0x000A84BC
		public HImage PaintXld(HImage image, double grayval)
		{
			IntPtr proc = HalconAPI.PreCall(575);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreD(proc, 0, grayval);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Copy an iconic object in the HALCON database.
		///   Instance represents: Objects to be copied.
		/// </summary>
		/// <param name="index">Starting index of the objects to be copied. Default: 1</param>
		/// <param name="numObj">Number of objects to be copied or -1. Default: 1</param>
		/// <returns>Copied objects.</returns>
		// Token: 0x06001B9E RID: 7070 RVA: 0x000AA31C File Offset: 0x000A851C
		public new HXLD CopyObj(int index, int numObj)
		{
			IntPtr proc = HalconAPI.PreCall(583);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.StoreI(proc, 1, numObj);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Concatenate two iconic object tuples.
		///   Instance represents: Object tuple 1.
		/// </summary>
		/// <param name="objects2">Object tuple 2.</param>
		/// <returns>Concatenated objects.</returns>
		// Token: 0x06001B9F RID: 7071 RVA: 0x000AA374 File Offset: 0x000A8574
		public HXLD ConcatObj(HXLD objects2)
		{
			IntPtr proc = HalconAPI.PreCall(584);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Select objects from an object tuple.
		///   Instance represents: Input objects.
		/// </summary>
		/// <param name="index">Indices of the objects to be selected. Default: 1</param>
		/// <returns>Selected objects.</returns>
		// Token: 0x06001BA0 RID: 7072 RVA: 0x000AA3CC File Offset: 0x000A85CC
		public new HXLD SelectObj(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(587);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select objects from an object tuple.
		///   Instance represents: Input objects.
		/// </summary>
		/// <param name="index">Indices of the objects to be selected. Default: 1</param>
		/// <returns>Selected objects.</returns>
		// Token: 0x06001BA1 RID: 7073 RVA: 0x000AA424 File Offset: 0x000A8624
		public new HXLD SelectObj(int index)
		{
			IntPtr proc = HalconAPI.PreCall(587);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compare iconic objects regarding equality.
		///   Instance represents: Reference objects.
		/// </summary>
		/// <param name="objects2">Test objects.</param>
		/// <param name="epsilon">Maximum allowed difference between two gray values or  coordinates etc. Default: 0.0</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x06001BA2 RID: 7074 RVA: 0x000AA474 File Offset: 0x000A8674
		public int CompareObj(HXLD objects2, HTuple epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(588);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.Store(proc, 0, epsilon);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(epsilon);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compare iconic objects regarding equality.
		///   Instance represents: Reference objects.
		/// </summary>
		/// <param name="objects2">Test objects.</param>
		/// <param name="epsilon">Maximum allowed difference between two gray values or  coordinates etc. Default: 0.0</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x06001BA3 RID: 7075 RVA: 0x000AA4D8 File Offset: 0x000A86D8
		public int CompareObj(HXLD objects2, double epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(588);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.StoreD(proc, 0, epsilon);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compare image objects regarding equality.
		///   Instance represents: Test objects.
		/// </summary>
		/// <param name="objects2">Comparative objects.</param>
		/// <returns>boolean result value.</returns>
		// Token: 0x06001BA4 RID: 7076 RVA: 0x000AA538 File Offset: 0x000A8738
		public int TestEqualObj(HXLD objects2)
		{
			IntPtr proc = HalconAPI.PreCall(591);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compute the mapping between the distorted image and the rectified image based upon the points of a regular grid.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="meshes">Output contours.</param>
		/// <param name="gridSpacing">Distance of the grid points in the rectified image.</param>
		/// <param name="rotation">Rotation to be applied to the point grid. Default: "auto"</param>
		/// <param name="row">Row coordinates of the grid points.</param>
		/// <param name="column">Column coordinates of the grid points.</param>
		/// <param name="mapType">Type of mapping. Default: "bilinear"</param>
		/// <returns>Image containing the mapping data.</returns>
		// Token: 0x06001BA5 RID: 7077 RVA: 0x000AA590 File Offset: 0x000A8790
		public HImage GenGridRectificationMap(HImage image, out HXLD meshes, int gridSpacing, HTuple rotation, HTuple row, HTuple column, string mapType)
		{
			IntPtr proc = HalconAPI.PreCall(1159);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreI(proc, 0, gridSpacing);
			HalconAPI.Store(proc, 1, rotation);
			HalconAPI.Store(proc, 2, row);
			HalconAPI.Store(proc, 3, column);
			HalconAPI.StoreS(proc, 4, mapType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLD.LoadNew(proc, 2, num, out meshes);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Compute the mapping between the distorted image and the rectified image based upon the points of a regular grid.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="meshes">Output contours.</param>
		/// <param name="gridSpacing">Distance of the grid points in the rectified image.</param>
		/// <param name="rotation">Rotation to be applied to the point grid. Default: "auto"</param>
		/// <param name="row">Row coordinates of the grid points.</param>
		/// <param name="column">Column coordinates of the grid points.</param>
		/// <param name="mapType">Type of mapping. Default: "bilinear"</param>
		/// <returns>Image containing the mapping data.</returns>
		// Token: 0x06001BA6 RID: 7078 RVA: 0x000AA63C File Offset: 0x000A883C
		public HImage GenGridRectificationMap(HImage image, out HXLD meshes, int gridSpacing, string rotation, HTuple row, HTuple column, string mapType)
		{
			IntPtr proc = HalconAPI.PreCall(1159);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreI(proc, 0, gridSpacing);
			HalconAPI.StoreS(proc, 1, rotation);
			HalconAPI.Store(proc, 2, row);
			HalconAPI.Store(proc, 3, column);
			HalconAPI.StoreS(proc, 4, mapType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLD.LoadNew(proc, 2, num, out meshes);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Deserialize a serialized XLD object.
		///   Modified instance represents: XLD object.
		/// </summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x06001BA7 RID: 7079 RVA: 0x000AA6E0 File Offset: 0x000A88E0
		public void DeserializeXld(HSerializedItem serializedItemHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1632);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>
		///   Serialize an XLD object.
		///   Instance represents: XLD object.
		/// </summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x06001BA8 RID: 7080 RVA: 0x000AA734 File Offset: 0x000A8934
		public HSerializedItem SerializeXld()
		{
			IntPtr proc = HalconAPI.PreCall(1633);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Test whether contours or polygons are closed.
		///   Instance represents: Contours or polygons to be tested.
		/// </summary>
		/// <returns>Tuple with boolean numbers.</returns>
		// Token: 0x06001BA9 RID: 7081 RVA: 0x000AA77C File Offset: 0x000A897C
		public HTuple TestClosedXld()
		{
			IntPtr proc = HalconAPI.PreCall(1667);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Arbitrary geometric moments of contours or polygons treated as point clouds.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="mode">Computation mode. Default: "unnormalized"</param>
		/// <param name="area">Area enclosed by the contour or polygon.</param>
		/// <param name="centerRow">Row coordinate of the centroid.</param>
		/// <param name="centerCol">Column coordinate of the centroid.</param>
		/// <param name="p">First index of the desired moments M[P,Q]@f$M_{p,q}$. Default: 1</param>
		/// <param name="q">Second index of the desired moments M[P,Q]@f$M_{p,q}$. Default: 1</param>
		/// <returns>The computed moments.</returns>
		// Token: 0x06001BAA RID: 7082 RVA: 0x000AA7C8 File Offset: 0x000A89C8
		public HTuple MomentsAnyPointsXld(string mode, HTuple area, HTuple centerRow, HTuple centerCol, HTuple p, HTuple q)
		{
			IntPtr proc = HalconAPI.PreCall(1669);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.Store(proc, 1, area);
			HalconAPI.Store(proc, 2, centerRow);
			HalconAPI.Store(proc, 3, centerCol);
			HalconAPI.Store(proc, 4, p);
			HalconAPI.Store(proc, 5, q);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(area);
			HalconAPI.UnpinTuple(centerRow);
			HalconAPI.UnpinTuple(centerCol);
			HalconAPI.UnpinTuple(p);
			HalconAPI.UnpinTuple(q);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Arbitrary geometric moments of contours or polygons treated as point clouds.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="mode">Computation mode. Default: "unnormalized"</param>
		/// <param name="area">Area enclosed by the contour or polygon.</param>
		/// <param name="centerRow">Row coordinate of the centroid.</param>
		/// <param name="centerCol">Column coordinate of the centroid.</param>
		/// <param name="p">First index of the desired moments M[P,Q]@f$M_{p,q}$. Default: 1</param>
		/// <param name="q">Second index of the desired moments M[P,Q]@f$M_{p,q}$. Default: 1</param>
		/// <returns>The computed moments.</returns>
		// Token: 0x06001BAB RID: 7083 RVA: 0x000AA868 File Offset: 0x000A8A68
		public double MomentsAnyPointsXld(string mode, double area, double centerRow, double centerCol, int p, int q)
		{
			IntPtr proc = HalconAPI.PreCall(1669);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreD(proc, 1, area);
			HalconAPI.StoreD(proc, 2, centerRow);
			HalconAPI.StoreD(proc, 3, centerCol);
			HalconAPI.StoreI(proc, 4, p);
			HalconAPI.StoreI(proc, 5, q);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Anisometry of contours or polygons treated as point clouds.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <returns>Anisometry of the contours or polygons.</returns>
		// Token: 0x06001BAC RID: 7084 RVA: 0x000AA8E4 File Offset: 0x000A8AE4
		public HTuple EccentricityPointsXld()
		{
			IntPtr proc = HalconAPI.PreCall(1670);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Parameters of the equivalent ellipse of contours or polygons treated as point clouds.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="rb">Minor radius.</param>
		/// <param name="phi">Angle between the major axis and the column axis (radians).</param>
		/// <returns>Major radius.</returns>
		// Token: 0x06001BAD RID: 7085 RVA: 0x000AA930 File Offset: 0x000A8B30
		public HTuple EllipticAxisPointsXld(out HTuple rb, out HTuple phi)
		{
			IntPtr proc = HalconAPI.PreCall(1671);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out rb);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out phi);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Parameters of the equivalent ellipse of contours or polygons treated as point clouds.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="rb">Minor radius.</param>
		/// <param name="phi">Angle between the major axis and the column axis (radians).</param>
		/// <returns>Major radius.</returns>
		// Token: 0x06001BAE RID: 7086 RVA: 0x000AA9A0 File Offset: 0x000A8BA0
		public double EllipticAxisPointsXld(out double rb, out double phi)
		{
			IntPtr proc = HalconAPI.PreCall(1671);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out rb);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Orientation of contours or polygons treated as point clouds.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <returns>Orientation of the contours or polygons (radians).</returns>
		// Token: 0x06001BAF RID: 7087 RVA: 0x000AAA0C File Offset: 0x000A8C0C
		public HTuple OrientationPointsXld()
		{
			IntPtr proc = HalconAPI.PreCall(1672);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments M20@f$M_{20}$, M02@f$M_{02}$, and M11@f$M_{11}$ of contours or polygons treated as point clouds.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="m20">Second order moment along the row axis.</param>
		/// <param name="m02">Second order moment along the column axis.</param>
		/// <returns>Mixed second order moment.</returns>
		// Token: 0x06001BB0 RID: 7088 RVA: 0x000AAA58 File Offset: 0x000A8C58
		public HTuple MomentsPointsXld(out HTuple m20, out HTuple m02)
		{
			IntPtr proc = HalconAPI.PreCall(1673);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out m20);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out m02);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments M20@f$M_{20}$, M02@f$M_{02}$, and M11@f$M_{11}$ of contours or polygons treated as point clouds.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="m20">Second order moment along the row axis.</param>
		/// <param name="m02">Second order moment along the column axis.</param>
		/// <returns>Mixed second order moment.</returns>
		// Token: 0x06001BB1 RID: 7089 RVA: 0x000AAAC8 File Offset: 0x000A8CC8
		public double MomentsPointsXld(out double m20, out double m02)
		{
			IntPtr proc = HalconAPI.PreCall(1673);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out m20);
			num = HalconAPI.LoadD(proc, 2, num, out m02);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Area and center of gravity (centroid) of contours and polygons treated as point clouds.
		///   Instance represents: Point clouds to be examined in form of contours or polygons.
		/// </summary>
		/// <param name="row">Row coordinate of the centroid.</param>
		/// <param name="column">Column coordinate of the centroid.</param>
		/// <returns>Area of the point cloud.</returns>
		// Token: 0x06001BB2 RID: 7090 RVA: 0x000AAB34 File Offset: 0x000A8D34
		public HTuple AreaCenterPointsXld(out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1674);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Area and center of gravity (centroid) of contours and polygons treated as point clouds.
		///   Instance represents: Point clouds to be examined in form of contours or polygons.
		/// </summary>
		/// <param name="row">Row coordinate of the centroid.</param>
		/// <param name="column">Column coordinate of the centroid.</param>
		/// <returns>Area of the point cloud.</returns>
		// Token: 0x06001BB3 RID: 7091 RVA: 0x000AABA4 File Offset: 0x000A8DA4
		public double AreaCenterPointsXld(out double row, out double column)
		{
			IntPtr proc = HalconAPI.PreCall(1674);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out row);
			num = HalconAPI.LoadD(proc, 2, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Test XLD contours or polygons for self intersection.
		///   Instance represents: Input contours or polygons.
		/// </summary>
		/// <param name="closeXLD">Should the input contours or polygons be closed first? Default: "true"</param>
		/// <returns>1 for contours or polygons with self intersection and 0 otherwise.</returns>
		// Token: 0x06001BB4 RID: 7092 RVA: 0x000AAC10 File Offset: 0x000A8E10
		public HTuple TestSelfIntersectionXld(string closeXLD)
		{
			IntPtr proc = HalconAPI.PreCall(1675);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, closeXLD);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Choose all contours or polygons containing a given point.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Line coordinate of the test point. Default: 100.0</param>
		/// <param name="column">Column coordinate of the test point. Default: 100.0</param>
		/// <returns>All contours or polygons containing the test point.</returns>
		// Token: 0x06001BB5 RID: 7093 RVA: 0x000AAC64 File Offset: 0x000A8E64
		public HXLD SelectXldPoint(HTuple row, HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1676);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Choose all contours or polygons containing a given point.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Line coordinate of the test point. Default: 100.0</param>
		/// <param name="column">Column coordinate of the test point. Default: 100.0</param>
		/// <returns>All contours or polygons containing the test point.</returns>
		// Token: 0x06001BB6 RID: 7094 RVA: 0x000AACC8 File Offset: 0x000A8EC8
		public HXLD SelectXldPoint(double row, double column)
		{
			IntPtr proc = HalconAPI.PreCall(1676);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Test whether one or more contours or polygons enclose the given point(s).
		///   Instance represents: Contours or polygons to be tested.
		/// </summary>
		/// <param name="row">Row coordinates of the points to be tested.</param>
		/// <param name="column">Column coordinates of the points to be tested.</param>
		/// <returns>Tuple with boolean numbers.</returns>
		// Token: 0x06001BB7 RID: 7095 RVA: 0x000AAD20 File Offset: 0x000A8F20
		public HTuple TestXldPoint(HTuple row, HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1677);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Test whether one or more contours or polygons enclose the given point(s).
		///   Instance represents: Contours or polygons to be tested.
		/// </summary>
		/// <param name="row">Row coordinates of the points to be tested.</param>
		/// <param name="column">Column coordinates of the points to be tested.</param>
		/// <returns>Tuple with boolean numbers.</returns>
		// Token: 0x06001BB8 RID: 7096 RVA: 0x000AAD88 File Offset: 0x000A8F88
		public int TestXldPoint(double row, double column)
		{
			IntPtr proc = HalconAPI.PreCall(1677);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select contours or polygons using shape features.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="features">Shape features to be checked. Default: "area"</param>
		/// <param name="operation">Operation type between the individual features. Default: "and"</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: 150.0</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: 99999.0</param>
		/// <returns>Contours or polygons fulfilling the condition(s).</returns>
		// Token: 0x06001BB9 RID: 7097 RVA: 0x000AADE0 File Offset: 0x000A8FE0
		public HXLD SelectShapeXld(HTuple features, string operation, HTuple min, HTuple max)
		{
			IntPtr proc = HalconAPI.PreCall(1678);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, features);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.Store(proc, 2, min);
			HalconAPI.Store(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(features);
			HalconAPI.UnpinTuple(min);
			HalconAPI.UnpinTuple(max);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select contours or polygons using shape features.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="features">Shape features to be checked. Default: "area"</param>
		/// <param name="operation">Operation type between the individual features. Default: "and"</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: 150.0</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: 99999.0</param>
		/// <returns>Contours or polygons fulfilling the condition(s).</returns>
		// Token: 0x06001BBA RID: 7098 RVA: 0x000AAE5C File Offset: 0x000A905C
		public HXLD SelectShapeXld(string features, string operation, double min, double max)
		{
			IntPtr proc = HalconAPI.PreCall(1678);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, features);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.StoreD(proc, 2, min);
			HalconAPI.StoreD(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Orientation of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <returns>Orientation of the contours or polygons (radians).</returns>
		// Token: 0x06001BBB RID: 7099 RVA: 0x000AAEC8 File Offset: 0x000A90C8
		public HTuple OrientationXld()
		{
			IntPtr proc = HalconAPI.PreCall(1679);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Shape features derived from the ellipse parameters of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="bulkiness">Bulkiness of the contours or polygons.</param>
		/// <param name="structureFactor">Structure factor of the contours or polygons.</param>
		/// <returns>Anisometry of the contours or polygons.</returns>
		// Token: 0x06001BBC RID: 7100 RVA: 0x000AAF14 File Offset: 0x000A9114
		public HTuple EccentricityXld(out HTuple bulkiness, out HTuple structureFactor)
		{
			IntPtr proc = HalconAPI.PreCall(1680);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out bulkiness);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out structureFactor);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Shape features derived from the ellipse parameters of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="bulkiness">Bulkiness of the contours or polygons.</param>
		/// <param name="structureFactor">Structure factor of the contours or polygons.</param>
		/// <returns>Anisometry of the contours or polygons.</returns>
		// Token: 0x06001BBD RID: 7101 RVA: 0x000AAF84 File Offset: 0x000A9184
		public double EccentricityXld(out double bulkiness, out double structureFactor)
		{
			IntPtr proc = HalconAPI.PreCall(1680);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out bulkiness);
			num = HalconAPI.LoadD(proc, 2, num, out structureFactor);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Shape factor for the compactness of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <returns>Compactness of the input contours or polygons.</returns>
		// Token: 0x06001BBE RID: 7102 RVA: 0x000AAFF0 File Offset: 0x000A91F0
		public HTuple CompactnessXld()
		{
			IntPtr proc = HalconAPI.PreCall(1681);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Maximum distance between two contour or polygon points.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row1">Row coordinate of the first extreme point of the contours or polygons.</param>
		/// <param name="column1">Column coordinate of the first extreme point of the contours or polygons.</param>
		/// <param name="row2">Row coordinate of the second extreme point of the contour or polygons.</param>
		/// <param name="column2">Column coordinate of the second extreme point of the contours or polygons.</param>
		/// <param name="diameter">Distance of the two extreme points of the contours or polygons.</param>
		// Token: 0x06001BBF RID: 7103 RVA: 0x000AB03C File Offset: 0x000A923C
		public void DiameterXld(out HTuple row1, out HTuple column1, out HTuple row2, out HTuple column2, out HTuple diameter)
		{
			IntPtr proc = HalconAPI.PreCall(1682);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row1);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column1);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out row2);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out column2);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out diameter);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Maximum distance between two contour or polygon points.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row1">Row coordinate of the first extreme point of the contours or polygons.</param>
		/// <param name="column1">Column coordinate of the first extreme point of the contours or polygons.</param>
		/// <param name="row2">Row coordinate of the second extreme point of the contour or polygons.</param>
		/// <param name="column2">Column coordinate of the second extreme point of the contours or polygons.</param>
		/// <param name="diameter">Distance of the two extreme points of the contours or polygons.</param>
		// Token: 0x06001BC0 RID: 7104 RVA: 0x000AB0D4 File Offset: 0x000A92D4
		public void DiameterXld(out double row1, out double column1, out double row2, out double column2, out double diameter)
		{
			IntPtr proc = HalconAPI.PreCall(1682);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row1);
			num = HalconAPI.LoadD(proc, 1, num, out column1);
			num = HalconAPI.LoadD(proc, 2, num, out row2);
			num = HalconAPI.LoadD(proc, 3, num, out column2);
			num = HalconAPI.LoadD(proc, 4, num, out diameter);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Shape factor for the convexity of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <returns>Convexity of the input contours or polygons.</returns>
		// Token: 0x06001BC1 RID: 7105 RVA: 0x000AB164 File Offset: 0x000A9364
		public HTuple ConvexityXld()
		{
			IntPtr proc = HalconAPI.PreCall(1683);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Shape factor for the circularity (similarity to a circle) of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <returns>Roundness of the input contours or polygons.</returns>
		// Token: 0x06001BC2 RID: 7106 RVA: 0x000AB1B0 File Offset: 0x000A93B0
		public HTuple CircularityXld()
		{
			IntPtr proc = HalconAPI.PreCall(1684);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Parameters of the equivalent ellipse of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="rb">Minor radius.</param>
		/// <param name="phi">Angle between the major axis and the x axis (radians).</param>
		/// <returns>Major radius.</returns>
		// Token: 0x06001BC3 RID: 7107 RVA: 0x000AB1FC File Offset: 0x000A93FC
		public HTuple EllipticAxisXld(out HTuple rb, out HTuple phi)
		{
			IntPtr proc = HalconAPI.PreCall(1685);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out rb);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out phi);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Parameters of the equivalent ellipse of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="rb">Minor radius.</param>
		/// <param name="phi">Angle between the major axis and the x axis (radians).</param>
		/// <returns>Major radius.</returns>
		// Token: 0x06001BC4 RID: 7108 RVA: 0x000AB26C File Offset: 0x000A946C
		public double EllipticAxisXld(out double rb, out double phi)
		{
			IntPtr proc = HalconAPI.PreCall(1685);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out rb);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Smallest enclosing rectangle with arbitrary orientation of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Row coordinate of the center point of the enclosing rectangle.</param>
		/// <param name="column">Column coordinate of the center point of the enclosing rectangle.</param>
		/// <param name="phi">Orientation of the enclosing rectangle (arc measure)</param>
		/// <param name="length1">First radius (half length) of the enclosing rectangle.</param>
		/// <param name="length2">Second radius (half width) of the enclosing rectangle.</param>
		// Token: 0x06001BC5 RID: 7109 RVA: 0x000AB2D8 File Offset: 0x000A94D8
		public void SmallestRectangle2Xld(out HTuple row, out HTuple column, out HTuple phi, out HTuple length1, out HTuple length2)
		{
			IntPtr proc = HalconAPI.PreCall(1686);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out phi);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out length1);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out length2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Smallest enclosing rectangle with arbitrary orientation of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Row coordinate of the center point of the enclosing rectangle.</param>
		/// <param name="column">Column coordinate of the center point of the enclosing rectangle.</param>
		/// <param name="phi">Orientation of the enclosing rectangle (arc measure)</param>
		/// <param name="length1">First radius (half length) of the enclosing rectangle.</param>
		/// <param name="length2">Second radius (half width) of the enclosing rectangle.</param>
		// Token: 0x06001BC6 RID: 7110 RVA: 0x000AB370 File Offset: 0x000A9570
		public void SmallestRectangle2Xld(out double row, out double column, out double phi, out double length1, out double length2)
		{
			IntPtr proc = HalconAPI.PreCall(1686);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			num = HalconAPI.LoadD(proc, 3, num, out length1);
			num = HalconAPI.LoadD(proc, 4, num, out length2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Enclosing rectangle parallel to the coordinate axes of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row1">Row coordinate of upper left corner point of the enclosing rectangle.</param>
		/// <param name="column1">Column coordinate of upper left corner point of the enclosing rectangle.</param>
		/// <param name="row2">Row coordinate of lower right corner point of the enclosing rectangle.</param>
		/// <param name="column2">Column coordinate of lower right corner point of the enclosing rectangle.</param>
		// Token: 0x06001BC7 RID: 7111 RVA: 0x000AB400 File Offset: 0x000A9600
		public void SmallestRectangle1Xld(out HTuple row1, out HTuple column1, out HTuple row2, out HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(1687);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row1);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column1);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out row2);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Enclosing rectangle parallel to the coordinate axes of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row1">Row coordinate of upper left corner point of the enclosing rectangle.</param>
		/// <param name="column1">Column coordinate of upper left corner point of the enclosing rectangle.</param>
		/// <param name="row2">Row coordinate of lower right corner point of the enclosing rectangle.</param>
		/// <param name="column2">Column coordinate of lower right corner point of the enclosing rectangle.</param>
		// Token: 0x06001BC8 RID: 7112 RVA: 0x000AB484 File Offset: 0x000A9684
		public void SmallestRectangle1Xld(out double row1, out double column1, out double row2, out double column2)
		{
			IntPtr proc = HalconAPI.PreCall(1687);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row1);
			num = HalconAPI.LoadD(proc, 1, num, out column1);
			num = HalconAPI.LoadD(proc, 2, num, out row2);
			num = HalconAPI.LoadD(proc, 3, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Smallest enclosing circle of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the enclosing circle.</param>
		/// <param name="column">Column coordinate of the center of the enclosing circle.</param>
		/// <param name="radius">Radius of the enclosing circle.</param>
		// Token: 0x06001BC9 RID: 7113 RVA: 0x000AB504 File Offset: 0x000A9704
		public void SmallestCircleXld(out HTuple row, out HTuple column, out HTuple radius)
		{
			IntPtr proc = HalconAPI.PreCall(1688);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out radius);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Smallest enclosing circle of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the enclosing circle.</param>
		/// <param name="column">Column coordinate of the center of the enclosing circle.</param>
		/// <param name="radius">Radius of the enclosing circle.</param>
		// Token: 0x06001BCA RID: 7114 RVA: 0x000AB574 File Offset: 0x000A9774
		public void SmallestCircleXld(out double row, out double column, out double radius)
		{
			IntPtr proc = HalconAPI.PreCall(1688);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out radius);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Transform the shape of contours or polygons.
		///   Instance represents: Contours or polygons to be transformed.
		/// </summary>
		/// <param name="type">Type of transformation. Default: "convex"</param>
		/// <returns>Transformed contours respectively polygons.</returns>
		// Token: 0x06001BCB RID: 7115 RVA: 0x000AB5E0 File Offset: 0x000A97E0
		public HXLD ShapeTransXld(string type)
		{
			IntPtr proc = HalconAPI.PreCall(1689);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Length of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <returns>Length of the contour or polygon.</returns>
		// Token: 0x06001BCC RID: 7116 RVA: 0x000AB630 File Offset: 0x000A9830
		public HTuple LengthXld()
		{
			IntPtr proc = HalconAPI.PreCall(1690);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Arbitrary geometric moments of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="mode">Computation mode. Default: "unnormalized"</param>
		/// <param name="pointOrder">Point order along the boundary. Default: "positive"</param>
		/// <param name="area">Area enclosed by the contour or polygon.</param>
		/// <param name="centerRow">Row coordinate of the centroid.</param>
		/// <param name="centerCol">Column coordinate of the centroid.</param>
		/// <param name="p">First index of the desired moments M[P,Q]@f$M_{p,q}$. Default: 1</param>
		/// <param name="q">Second index of the desired moments M[P,Q]@f$M_{p,q}$. Default: 1</param>
		/// <returns>The computed moments.</returns>
		// Token: 0x06001BCD RID: 7117 RVA: 0x000AB67C File Offset: 0x000A987C
		public HTuple MomentsAnyXld(string mode, HTuple pointOrder, HTuple area, HTuple centerRow, HTuple centerCol, HTuple p, HTuple q)
		{
			IntPtr proc = HalconAPI.PreCall(1691);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.Store(proc, 1, pointOrder);
			HalconAPI.Store(proc, 2, area);
			HalconAPI.Store(proc, 3, centerRow);
			HalconAPI.Store(proc, 4, centerCol);
			HalconAPI.Store(proc, 5, p);
			HalconAPI.Store(proc, 6, q);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pointOrder);
			HalconAPI.UnpinTuple(area);
			HalconAPI.UnpinTuple(centerRow);
			HalconAPI.UnpinTuple(centerCol);
			HalconAPI.UnpinTuple(p);
			HalconAPI.UnpinTuple(q);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Arbitrary geometric moments of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="mode">Computation mode. Default: "unnormalized"</param>
		/// <param name="pointOrder">Point order along the boundary. Default: "positive"</param>
		/// <param name="area">Area enclosed by the contour or polygon.</param>
		/// <param name="centerRow">Row coordinate of the centroid.</param>
		/// <param name="centerCol">Column coordinate of the centroid.</param>
		/// <param name="p">First index of the desired moments M[P,Q]@f$M_{p,q}$. Default: 1</param>
		/// <param name="q">Second index of the desired moments M[P,Q]@f$M_{p,q}$. Default: 1</param>
		/// <returns>The computed moments.</returns>
		// Token: 0x06001BCE RID: 7118 RVA: 0x000AB72C File Offset: 0x000A992C
		public double MomentsAnyXld(string mode, string pointOrder, double area, double centerRow, double centerCol, int p, int q)
		{
			IntPtr proc = HalconAPI.PreCall(1691);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreS(proc, 1, pointOrder);
			HalconAPI.StoreD(proc, 2, area);
			HalconAPI.StoreD(proc, 3, centerRow);
			HalconAPI.StoreD(proc, 4, centerCol);
			HalconAPI.StoreI(proc, 5, p);
			HalconAPI.StoreI(proc, 6, q);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments M20@f$M_{20}$, M02@f$M_{02}$, and M11@f$M_{11}$ of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="m20">Second order moment along the row axis.</param>
		/// <param name="m02">Second order moment along the column axis.</param>
		/// <returns>Mixed second order moment.</returns>
		// Token: 0x06001BCF RID: 7119 RVA: 0x000AB7B0 File Offset: 0x000A99B0
		public HTuple MomentsXld(out HTuple m20, out HTuple m02)
		{
			IntPtr proc = HalconAPI.PreCall(1692);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out m20);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out m02);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Geometric moments M20@f$M_{20}$, M02@f$M_{02}$, and M11@f$M_{11}$ of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="m20">Second order moment along the row axis.</param>
		/// <param name="m02">Second order moment along the column axis.</param>
		/// <returns>Mixed second order moment.</returns>
		// Token: 0x06001BD0 RID: 7120 RVA: 0x000AB820 File Offset: 0x000A9A20
		public double MomentsXld(out double m20, out double m02)
		{
			IntPtr proc = HalconAPI.PreCall(1692);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out m20);
			num = HalconAPI.LoadD(proc, 2, num, out m02);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Area and center of gravity (centroid) of contours and polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Row coordinate of the centroid.</param>
		/// <param name="column">Column coordinate of the centroid.</param>
		/// <param name="pointOrder">point order along the boundary ('positive'/'negative').</param>
		/// <returns>Area enclosed by the contour or polygon.</returns>
		// Token: 0x06001BD1 RID: 7121 RVA: 0x000AB88C File Offset: 0x000A9A8C
		public HTuple AreaCenterXld(out HTuple row, out HTuple column, out HTuple pointOrder)
		{
			IntPtr proc = HalconAPI.PreCall(1693);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 3, num, out pointOrder);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Area and center of gravity (centroid) of contours and polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Row coordinate of the centroid.</param>
		/// <param name="column">Column coordinate of the centroid.</param>
		/// <param name="pointOrder">point order along the boundary ('positive'/'negative').</param>
		/// <returns>Area enclosed by the contour or polygon.</returns>
		// Token: 0x06001BD2 RID: 7122 RVA: 0x000AB910 File Offset: 0x000A9B10
		public double AreaCenterXld(out double row, out double column, out string pointOrder)
		{
			IntPtr proc = HalconAPI.PreCall(1693);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out row);
			num = HalconAPI.LoadD(proc, 2, num, out column);
			num = HalconAPI.LoadS(proc, 3, num, out pointOrder);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the 3D pose of a rectangle from its perspective 2D projection
		///   Instance represents: Contour(s) to be examined.
		/// </summary>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <param name="width">Width of the rectangle in meters.</param>
		/// <param name="height">Height of the rectangle in meters.</param>
		/// <param name="weightingMode">Weighting mode for the optimization phase. Default: "nonweighted"</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers (typical: 1.0 for 'huber' and 3.0 for 'tukey'). Default: 2.0</param>
		/// <param name="covPose">Covariances of the pose values.</param>
		/// <param name="error">Root-mean-square value of the final residual error.</param>
		/// <returns>3D pose of the rectangle.</returns>
		// Token: 0x06001BD3 RID: 7123 RVA: 0x000AB990 File Offset: 0x000A9B90
		public HPose[] GetRectanglePose(HCamPar cameraParam, HTuple width, HTuple height, string weightingMode, double clippingFactor, out HTuple covPose, out HTuple error)
		{
			IntPtr proc = HalconAPI.PreCall(1908);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, cameraParam);
			HalconAPI.Store(proc, 1, width);
			HalconAPI.Store(proc, 2, height);
			HalconAPI.StoreS(proc, 3, weightingMode);
			HalconAPI.StoreD(proc, 4, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			HalconAPI.UnpinTuple(width);
			HalconAPI.UnpinTuple(height);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covPose);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out error);
			HalconAPI.PostCall(proc, num);
			HPose[] result = HPose.SplitArray(data);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the 3D pose of a rectangle from its perspective 2D projection
		///   Instance represents: Contour(s) to be examined.
		/// </summary>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <param name="width">Width of the rectangle in meters.</param>
		/// <param name="height">Height of the rectangle in meters.</param>
		/// <param name="weightingMode">Weighting mode for the optimization phase. Default: "nonweighted"</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers (typical: 1.0 for 'huber' and 3.0 for 'tukey'). Default: 2.0</param>
		/// <param name="covPose">Covariances of the pose values.</param>
		/// <param name="error">Root-mean-square value of the final residual error.</param>
		/// <returns>3D pose of the rectangle.</returns>
		// Token: 0x06001BD4 RID: 7124 RVA: 0x000ABA4C File Offset: 0x000A9C4C
		public HPose GetRectanglePose(HCamPar cameraParam, double width, double height, string weightingMode, double clippingFactor, out HTuple covPose, out HTuple error)
		{
			IntPtr proc = HalconAPI.PreCall(1908);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, cameraParam);
			HalconAPI.StoreD(proc, 1, width);
			HalconAPI.StoreD(proc, 2, height);
			HalconAPI.StoreS(proc, 3, weightingMode);
			HalconAPI.StoreD(proc, 4, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covPose);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out error);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the 3D pose of a circle from its perspective 2D projection. 
		///   Instance represents: Contours to be examined.
		/// </summary>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <param name="radius">Radius of the circle in object space.</param>
		/// <param name="outputType">Type of output parameters. Default: "pose"</param>
		/// <param name="pose2">3D pose of the second circle.</param>
		/// <returns>3D pose of the first circle.</returns>
		// Token: 0x06001BD5 RID: 7125 RVA: 0x000ABAF8 File Offset: 0x000A9CF8
		public HTuple GetCirclePose(HCamPar cameraParam, HTuple radius, string outputType, out HTuple pose2)
		{
			IntPtr proc = HalconAPI.PreCall(1909);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, cameraParam);
			HalconAPI.Store(proc, 1, radius);
			HalconAPI.StoreS(proc, 2, outputType);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			HalconAPI.UnpinTuple(radius);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out pose2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Determine the 3D pose of a circle from its perspective 2D projection. 
		///   Instance represents: Contours to be examined.
		/// </summary>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <param name="radius">Radius of the circle in object space.</param>
		/// <param name="outputType">Type of output parameters. Default: "pose"</param>
		/// <param name="pose2">3D pose of the second circle.</param>
		/// <returns>3D pose of the first circle.</returns>
		// Token: 0x06001BD6 RID: 7126 RVA: 0x000ABB84 File Offset: 0x000A9D84
		public HTuple GetCirclePose(HCamPar cameraParam, double radius, string outputType, out HTuple pose2)
		{
			IntPtr proc = HalconAPI.PreCall(1909);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, cameraParam);
			HalconAPI.StoreD(proc, 1, radius);
			HalconAPI.StoreS(proc, 2, outputType);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, num, out pose2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the width, height, and aspect ratio of the enclosing rectangle parallel to the coordinate axes of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="width">Width of the enclosing rectangle.</param>
		/// <param name="ratio">Aspect ratio of the enclosing rectangle.</param>
		/// <returns>Height of the enclosing rectangle.</returns>
		// Token: 0x06001BD7 RID: 7127 RVA: 0x000ABC08 File Offset: 0x000A9E08
		public HTuple HeightWidthRatioXld(out HTuple width, out HTuple ratio)
		{
			IntPtr proc = HalconAPI.PreCall(2120);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out width);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out ratio);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the width, height, and aspect ratio of the enclosing rectangle parallel to the coordinate axes of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="width">Width of the enclosing rectangle.</param>
		/// <param name="ratio">Aspect ratio of the enclosing rectangle.</param>
		/// <returns>Height of the enclosing rectangle.</returns>
		// Token: 0x06001BD8 RID: 7128 RVA: 0x000ABC78 File Offset: 0x000A9E78
		public double HeightWidthRatioXld(out double width, out double ratio)
		{
			IntPtr proc = HalconAPI.PreCall(2120);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out width);
			num = HalconAPI.LoadD(proc, 2, num, out ratio);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Insert objects into an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="objectsInsert">Object tuple to insert.</param>
		/// <param name="index">Index to insert objects.</param>
		/// <returns>Extended object tuple.</returns>
		// Token: 0x06001BD9 RID: 7129 RVA: 0x000ABCE4 File Offset: 0x000A9EE4
		public HXLD InsertObj(HXLD objectsInsert, int index)
		{
			IntPtr proc = HalconAPI.PreCall(2121);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsInsert);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsInsert);
			return result;
		}

		/// <summary>
		///   Remove objects from an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="index">Indices of the objects to be removed.</param>
		/// <returns>Remaining object tuple.</returns>
		// Token: 0x06001BDA RID: 7130 RVA: 0x000ABD44 File Offset: 0x000A9F44
		public new HXLD RemoveObj(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(2124);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove objects from an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="index">Indices of the objects to be removed.</param>
		/// <returns>Remaining object tuple.</returns>
		// Token: 0x06001BDB RID: 7131 RVA: 0x000ABD9C File Offset: 0x000A9F9C
		public new HXLD RemoveObj(int index)
		{
			IntPtr proc = HalconAPI.PreCall(2124);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Replaces one or more elements of an iconic object tuple.
		///   Instance represents: Iconic Input Object.
		/// </summary>
		/// <param name="objectsReplace">Element(s) to replace.</param>
		/// <param name="index">Index/Indices of elements to be replaced.</param>
		/// <returns>Tuple with replaced elements.</returns>
		// Token: 0x06001BDC RID: 7132 RVA: 0x000ABDEC File Offset: 0x000A9FEC
		public HXLD ReplaceObj(HXLD objectsReplace, HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(2125);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsReplace);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsReplace);
			return result;
		}

		/// <summary>
		///   Replaces one or more elements of an iconic object tuple.
		///   Instance represents: Iconic Input Object.
		/// </summary>
		/// <param name="objectsReplace">Element(s) to replace.</param>
		/// <param name="index">Index/Indices of elements to be replaced.</param>
		/// <returns>Tuple with replaced elements.</returns>
		// Token: 0x06001BDD RID: 7133 RVA: 0x000ABE50 File Offset: 0x000AA050
		public HXLD ReplaceObj(HXLD objectsReplace, int index)
		{
			IntPtr proc = HalconAPI.PreCall(2125);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsReplace);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLD result;
			num = HXLD.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsReplace);
			return result;
		}

		/// <summary>
		///   Shape factor for the rectangularity of contours or polygons.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <returns>Rectangularity of the input contours or polygons.</returns>
		// Token: 0x06001BDE RID: 7134 RVA: 0x000ABEB0 File Offset: 0x000AA0B0
		public HTuple RectangularityXld()
		{
			IntPtr proc = HalconAPI.PreCall(2186);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}
	}
}
